#include "class.h"

//C++类的构造函数


// int main()
// {
//     Date d1;
//     //以下两个写法都等价 
//     Date da(d1);
//     Date db = d1;//因此这种写法让人会误以为没有调用浅拷贝构造
//     return 0;
// }



class A{
public : 
    A(int a)
    :_a(a)
    {
        cout<<"A(int a)"<<endl;
    }
    A(const A& a1)
    :_a(a1._a)
    {
        cout<<"A(const A& a1)"<<endl;
    }
    ~A()
    {
        cout<<"~A"<<endl;
    }
private :
int _a = 0;
};

class B{
public:
    class A;
    B(int b1 ,int b2)
    :_b1(b1)
    ,_b2(b2)
    {

    }
private:
 int _b1 ;
 int _b2 ;
};


// int main()
// {
//     A aa(1);//初始化构造
//     A aaa = 2;//c++的一种隐式类型转换，先对1调用A的构造函数，生成一个临时对象，调用拷贝构造把临时对象赋值给aaa，但是编译器会进行优化直接用2进行构造
//     //证据：
//     //A& aaa2 = 1;//这里编译器会报错，原因是一个临时对象（不可修改）的赋值给引用，权限就被放大了，
//     const A& aaa2 = 1;//这里加上const就能编译过去
//     //假如不想隐式类型转换发生，    explicit加在构造函数前就可以，就不会允许这种转换


//     //c++11还支持多个数据
//     B bb2(1,2);
//     B bb3 = {1 , 1};
//     const B& bb4  = {1,3};//也就是在传值去进行构造时，加一个花括号即可


//     //匿名对象，生命周期只在这一行，注意是一行
//     A(7);
//     //例如给顺序表传数据，和在某些只需要调用一行的类，用隐式类型转换就会很方便
//     //例子如下
//     A(7).~A();


//     A a1(1);
//     a1.~A();//调用了析构函数不代表变量的生命周期结束
//     a1 = 2;//这里时赋值重载，调用了编译器自己默认生成的赋值重载函数 
//     return 0;
// }


class stack{
    stack()
    :capacity(10)
    ,sz(0)
    ,a((int*)malloc(sizeof(int)*10))
    {

    }
    stack(stack& ST)//
    {
        this->a = (int*)malloc(ST.capacity*sizeof(int));
        this->capacity = ST.capacity;
        this->sz = ST.sz;
    }
    stack operator=(const stack& ST)
    {
        this->a = ST.a;
        this->capacity = ST.capacity;
        this->sz = ST.sz;
        return *this;
    }
private:
int *a ;
int capacity;
int sz;
};


class C{
    public:
    C(int a,int b)
    {

    }
};

int main()
{
    C c = {1,2};
    C cc[2] = {{1,2},{3,4}};
    return 0;
}